home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / fractal / frasr182 / lorenz.c < prev    next >
C/C++ Source or Header  |  1993-07-26  |  69KB  |  2,586 lines
  1. /*
  2.    This file contains two 3 dimensional orbit-type fractal
  3.    generators - IFS and LORENZ3D, along with code to generate
  4.    red/blue 3D images. Tim Wegner
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <float.h>
  10. #include <math.h>
  11. #include <string.h>
  12. #include "mpmath.h"
  13. #include "fractint.h"
  14. #include "fractype.h"
  15. #include "prototyp.h"
  16.  
  17. #define RANDOM(x)  (rand()%(x))
  18.  
  19. /* BAD_PIXEL is used to cutoff orbits that are diverging. It might be better
  20. to test the actual floating point prbit values, but this seems safe for now.
  21. A higher value cannot be used - to test, turn off math coprocessor and
  22. use +2.24 for type ICONS. If BAD_PIXEL is set to 20000, this will abort
  23. Fractint with a math error. Note that this approach precludes zooming in very
  24. far to an orbit type. */
  25.  
  26. #define BAD_PIXEL  10000L    /* pixels can't get this big */
  27.  
  28. struct affine
  29. {
  30.    /* weird order so a,b,e and c,d,f are vectors */
  31.    double a;
  32.    double b;
  33.    double e;
  34.    double c;
  35.    double d;
  36.    double f;
  37. };
  38. struct l_affine
  39. {
  40.    /* weird order so a,b,e and c,d,f are vectors */
  41.    long a;
  42.    long b;
  43.    long e;
  44.    long c;
  45.    long d;
  46.    long f;
  47. };
  48. struct long3dvtinf /* data used by 3d view transform subroutine */
  49. {
  50.    long ct;        /* iteration counter */
  51.    long orbit[3];    /* interated function orbit value */
  52.    long iview[3];    /* perspective viewer's coordinates */
  53.    long viewvect[3];    /* orbit transformed for viewing */
  54.    long viewvect1[3];    /* orbit transformed for viewing */
  55.    long maxvals[3];
  56.    long minvals[3];
  57.    MATRIX doublemat;    /* transformation matrix */
  58.    MATRIX doublemat1;    /* transformation matrix */
  59.    long longmat[4][4];    /* long version of matrix */
  60.    long longmat1[4][4]; /* long version of matrix */
  61.    int row,col;     /* results */
  62.    int row1,col1;
  63.    struct l_affine cvt;
  64. };
  65. struct float3dvtinf /* data used by 3d view transform subroutine */
  66. {
  67.    long ct;        /* iteration counter */
  68.    double orbit[3];           /* interated function orbit value */
  69.    double viewvect[3];          /* orbit transformed for viewing */
  70.    double viewvect1[3];        /* orbit transformed for viewing */
  71.    double maxvals[3];
  72.    double minvals[3];
  73.    MATRIX doublemat;    /* transformation matrix */
  74.    MATRIX doublemat1;    /* transformation matrix */
  75.    int row,col;     /* results */
  76.    int row1,col1;
  77.    struct affine cvt;
  78. };
  79.  
  80. /* Routines in this module    */
  81.  
  82. static int  ifs3dlong(void);
  83. static int  ifs3dfloat(void);
  84. static double determinant(double mat[3][3]);
  85. static int  solve3x3(double mat[3][3],double vec[3],double ans[3]);
  86. extern int  setup_convert_to_screen(struct affine *);
  87. static int  l_setup_convert_to_screen(struct l_affine *);
  88. static void setupmatrix(MATRIX);
  89. static int  long3dviewtransf(struct long3dvtinf *inf);
  90. static int  float3dviewtransf(struct float3dvtinf *inf);
  91. static FILE *open_orbitsave();
  92. static void _fastcall plothist(int x, int y, int color);
  93. extern char far insufficient_ifs_mem[];
  94. extern int numaffine;
  95. static int realtime;
  96. extern int orbitsave;
  97. static char orbitsavename[]    = {"orbits.raw"};
  98. static char orbitsave_format[] = {"%g %g %g 15\n"};
  99. extern int active_system;
  100. extern int overflow;
  101. extern int soundflag;
  102. extern int basehertz;
  103. extern int fractype;
  104. extern int glassestype;
  105. extern int whichimage;
  106. extern int init3d[];
  107. extern char floatflag;
  108. extern VECTOR view;
  109. extern int xxadjust, yyadjust;
  110. extern int xxadjust1, yyadjust1;
  111. extern int xshift,yshift;
  112. extern int xshift1,yshift1;
  113. extern int    debugflag;            /* for debugging purposes */
  114. extern int    xdots, ydots;        /* coordinates of dots on the screen  */
  115. extern int    maxit;                /* try this many iterations */
  116. extern double param[];
  117. extern double    xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* selected screen corners  */
  118. extern    int    diskvideo;            /* for disk-video klooges */
  119. extern int    bitshift;            /* bit shift for fudge */
  120. extern long    fudge;                /* fudge factor (2**n) */
  121. extern int    colors;             /* maximum colors available */
  122. extern int display3d;
  123. extern double dxsize,dysize,delxx,delxx2,delyy,delyy2;
  124.  
  125. extern float far *ifs_defn;
  126. extern int ifs_type;
  127.  
  128. static int t;
  129. static long l_dx,l_dy,l_dz,l_dt,l_a,l_b,l_c,l_d;
  130. static long l_adt,l_bdt,l_cdt,l_xdt,l_ydt;
  131. static long l_initx,l_inity,l_initz;
  132. static long initorbitlong[3];
  133.  
  134. static double dx,dy,dz,dt,a,b,c,d;
  135. static double adt,bdt,cdt,xdt,ydt,zdt;
  136. static double initx,inity,initz;
  137. static double initorbit[3];
  138. extern int inside;
  139. extern int outside;
  140. extern int orbit_delay;
  141.  
  142. extern void (_fastcall * standardplot)(int,int,int);
  143. extern int  calc_status, resuming;
  144. extern int  diskisactive;
  145. extern char savename[];
  146.  
  147. /*
  148.  * The following declarations used for Inverse Julia.  MVS
  149.  */
  150.  
  151. extern int    Init_Queue      (unsigned long);
  152. extern void   Free_Queue      (void);
  153. extern void   ClearQueue      (void);
  154. extern int    QueueEmpty      (void);
  155. extern int    QueueFull       (void);
  156. extern int    QueueFullAlmost (void);
  157. extern int    PushLong        (long ,  long);
  158. extern int    PushFloat       (float,  float);
  159. extern int    EnQueueLong     (long ,  long);
  160. extern int    EnQueueFloat    (float,  float);
  161. extern LCMPLX PopLong         (void);
  162. extern _CMPLX PopFloat        (void);
  163. extern LCMPLX DeQueueLong     (void);
  164. extern _CMPLX DeQueueFloat    (void);
  165. extern LCMPLX ComplexSqrtLong (long ,  long);
  166. extern _CMPLX ComplexSqrtFloat(double, double);
  167. static char far NoQueue[] =
  168.   "Not enough memory: switching to random walk.\n";
  169.  
  170. static int    maxhits;
  171. int    run_length;
  172. enum   {breadth_first, depth_first, random_walk, random_run} major_method;
  173. enum   {left_first, right_first}                             minor_method;
  174. struct affine cvt;
  175. struct l_affine lcvt;
  176.  
  177. extern _CMPLX  old,  new;
  178. extern LCMPLX lold, lnew;
  179.  
  180. double Cx, Cy;
  181. long   CxLong, CyLong;
  182.  
  183. /*
  184.  * end of Inverse Julia declarations;
  185.  */
  186.  
  187. /* these are potential user parameters */
  188. int connect = 1;    /* flag to connect points with a line */
  189. int euler = 0;        /* use implicit euler approximation for dynamic system */
  190. int waste = 100;    /* waste this many points before plotting */
  191. int projection = 2; /* projection plane - default is to plot x-y */
  192.  
  193. /******************************************************************/
  194. /*           zoom box conversion functions          */
  195. /******************************************************************/
  196.  
  197. static double determinant(mat) /* determinant of 3x3 matrix */
  198. double mat[3][3];
  199. {
  200.    /* calculate determinant of 3x3 matrix */
  201.    return(mat[0][0]*mat[1][1]*mat[2][2] +
  202.       mat[0][2]*mat[1][0]*mat[2][1] +
  203.       mat[0][1]*mat[1][2]*mat[2][0] -
  204.       mat[2][0]*mat[1][1]*mat[0][2] -
  205.       mat[1][0]*mat[0][1]*mat[2][2] -
  206.       mat[0][0]*mat[1][2]*mat[2][1]);
  207.  
  208. }
  209.  
  210. static int solve3x3(mat,vec,ans) /* solve 3x3 inhomogeneous linear equations */
  211. double mat[3][3], vec[3], ans[3];
  212. {
  213.    /* solve 3x3 linear equation [mat][ans] = [vec] */
  214.    double denom;
  215.    double tmp[3][3];
  216.    int i;
  217.    denom = determinant(mat);
  218.    if(fabs(denom) < DBL_EPSILON) /* test if can solve */
  219.      return(-1);
  220.    memcpy(tmp,mat,sizeof(double)*9);
  221.    for(i=0;i<3;i++)
  222.    {
  223.       tmp[0][i] = vec[0];
  224.       tmp[1][i] = vec[1];
  225.       tmp[2][i] = vec[2];
  226.       ans[i]  =  determinant(tmp)/denom;
  227.       tmp[0][i] = mat[0][i];
  228.       tmp[1][i] = mat[1][i];
  229.       tmp[2][i] = mat[2][i];
  230.     }
  231.     return(0);
  232. }
  233.  
  234.  
  235. /* Conversion of complex plane to screen coordinates for rotating zoom box.
  236.    Assume there is an affine transformation mapping complex zoom parallelogram
  237.    to rectangular screen. We know this map must map parallelogram corners to
  238.    screen corners, so we have following equations:
  239.  
  240.       a*xxmin+b*yymax+e == 0        (upper left)
  241.       c*xxmin+d*yymax+f == 0
  242.  
  243.       a*xx3rd+b*yy3rd+e == 0        (lower left)
  244.       c*xx3rd+d*yy3rd+f == ydots-1
  245.  
  246.       a*xxmax+b*yymin+e == xdots-1  (lower right)
  247.       c*xxmax+d*yymin+f == ydots-1
  248.  
  249.       First we must solve for a,b,c,d,e,f - (which we do once per image),
  250.       then we just apply the transformation to each orbit value.
  251. */
  252.  
  253. int setup_convert_to_screen(struct affine *scrn_cnvt)
  254. {
  255.    /* we do this twice - rather than having six equations with six unknowns,
  256.       everything partitions to two sets of three equations with three
  257.       unknowns. Nice, because who wants to calculate a 6x6 determinant??
  258.     */
  259.    double mat[3][3];
  260.    double vec[3];
  261.    /*
  262.       first these equations - solve for a,b,e
  263.       a*xxmin+b*yymax+e == 0        (upper left)
  264.       a*xx3rd+b*yy3rd+e == 0        (lower left)
  265.       a*xxmax+b*yymin+e == xdots-1  (lower right)
  266.    */
  267.    mat[0][0] = xxmin;
  268.    mat[0][1] = yymax;
  269.    mat[0][2] = 1.0;
  270.    mat[1][0] = xx3rd;
  271.    mat[1][1] = yy3rd;
  272.    mat[1][2] = 1.0;
  273.    mat[2][0] = xxmax;
  274.    mat[2][1] = yymin;
  275.    mat[2][2] = 1.0;
  276.    vec[0]    = 0.0;
  277.    vec[1]    = 0.0;
  278.    vec[2]    = (double)(xdots-1);
  279.  
  280.    if(solve3x3(mat,vec, &(scrn_cnvt->a)))
  281.       return(-1);
  282.    /*
  283.       now solve these:
  284.       c*xxmin+d*yymax+f == 0
  285.       c*xx3rd+d*yy3rd+f == ydots-1
  286.       c*xxmax+d*yymin+f == ydots-1
  287.       (mat[][] has not changed - only vec[])
  288.    */
  289.    vec[0]    = 0.0;
  290.    vec[1]    = (double)(ydots-1);
  291.    vec[2]    = (double)(ydots-1);
  292.  
  293.    if(solve3x3(mat,vec, &scrn_cnvt->c))
  294.       return(-1);
  295.    return(0);
  296. }
  297.  
  298. static int l_setup_convert_to_screen(struct l_affine *l_cvt)
  299. {
  300.    struct affine cvt;
  301.  
  302.    /* MCP 7-7-91, This function should return a something! */
  303.    if(setup_convert_to_screen(&cvt))
  304.       return(-1);
  305.    l_cvt->a = cvt.a*fudge; l_cvt->b = cvt.b*fudge; l_cvt->c = cvt.c*fudge;
  306.    l_cvt->d = cvt.d*fudge; l_cvt->e = cvt.e*fudge; l_cvt->f = cvt.f*fudge;
  307.  
  308.    /* MCP 7-7-91 */
  309.    return(0);
  310. }
  311.  
  312.  
  313. /******************************************************************/
  314. /*   setup functions - put in fractalspecific[fractype].per_image */
  315. /******************************************************************/
  316.  
  317. static double orbit;
  318. static long   l_orbit;
  319.  
  320. extern double sinx,cosx;
  321. static long l_sinx,l_cosx;
  322.  
  323. int orbit3dlongsetup()
  324. {
  325.    connect = 1;
  326.    waste = 100;
  327.    projection = 2;
  328.    if (fractype==LHENON || fractype==KAM || fractype==KAM3D || 
  329.        fractype==INVERSEJULIA)
  330.       connect=0;
  331.    if(fractype==LROSSLER)
  332.       waste = 500;
  333.    if(fractype==LLORENZ)
  334.       projection = 1;
  335.  
  336.    initorbitlong[0] = fudge;  /* initial conditions */
  337.    initorbitlong[1] = fudge;
  338.    initorbitlong[2] = fudge;
  339.  
  340.    if(fractype==LHENON)
  341.    {
  342.       l_a =  param[0]*fudge;
  343.       l_b =  param[1]*fudge;
  344.       l_c =  param[2]*fudge;
  345.       l_d =  param[3]*fudge;
  346.    }
  347.    else if(fractype==KAM || fractype==KAM3D)
  348.    {
  349.       a   = param[0];        /* angle */
  350.       if(param[1] <= 0.0)
  351.      param[1] = .01;
  352.       l_b =  param[1]*fudge;    /* stepsize */
  353.       l_c =  param[2]*fudge;    /* stop */
  354.       t = l_d =  param[3];     /* points per orbit */
  355.  
  356.       l_sinx = sin(a)*fudge;
  357.       l_cosx = cos(a)*fudge;
  358.       l_orbit = 0;
  359.       initorbitlong[0] = initorbitlong[1] = initorbitlong[2] = 0;
  360.    }
  361.    else if (fractype == INVERSEJULIA)
  362.    {
  363.       LCMPLX Sqrt;
  364.  
  365.       CxLong = param[0] * fudge;
  366.       CyLong = param[1] * fudge;
  367.  
  368.       maxhits    = (int) param[2];
  369.       run_length = (int) param[3];
  370.       if (maxhits == 0)
  371.       maxhits = 1;
  372.       else if (maxhits >= colors)
  373.       maxhits = colors - 1;
  374.  
  375.       setup_convert_to_screen(&cvt);
  376.       /* Note: using bitshift of 21 for affine, 24 otherwise */
  377.  
  378.       lcvt.a = cvt.a * (1L << 21);
  379.       lcvt.b = cvt.b * (1L << 21);
  380.       lcvt.c = cvt.c * (1L << 21);
  381.       lcvt.d = cvt.d * (1L << 21);
  382.       lcvt.e = cvt.e * (1L << 21);
  383.       lcvt.f = cvt.f * (1L << 21);
  384.  
  385.       Sqrt = ComplexSqrtLong(fudge - 4 * CxLong, -4 * CyLong);
  386.  
  387.       switch (major_method) {
  388.      case breadth_first:
  389.         if (Init_Queue((long)32*1024) == 0)
  390.         { /* can't get queue memory: fall back to random walk */
  391.            stopmsg(20, NoQueue);
  392.            major_method = random_walk;
  393.            goto lrwalk;
  394.         }
  395.         EnQueueLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
  396.         EnQueueLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
  397.         break;
  398.      case depth_first:
  399.         if (Init_Queue((long)32*1024) == 0)
  400.         { /* can't get queue memory: fall back to random walk */
  401.            stopmsg(20, NoQueue);
  402.            major_method = random_walk;
  403.            goto lrwalk;
  404.         }
  405.         switch (minor_method) {
  406.            case left_first:
  407.           PushLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
  408.           PushLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
  409.           break;
  410.            case right_first:
  411.           PushLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
  412.           PushLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
  413.           break;
  414.         }
  415.         break;
  416.      case random_walk:
  417. lrwalk:
  418.         lnew.x = initorbitlong[0] = fudge + Sqrt.x / 2;
  419.         lnew.y = initorbitlong[1] =         Sqrt.y / 2;
  420.         break;
  421.      case random_run:
  422.         lnew.x = initorbitlong[0] = fudge + Sqrt.x / 2;
  423.         lnew.y = initorbitlong[1] =         Sqrt.y / 2;
  424.         break;
  425.       }
  426.    }
  427.    else
  428.    {
  429.       l_dt = param[0]*fudge;
  430.       l_a =  param[1]*fudge;
  431.       l_b =  param[2]*fudge;
  432.       l_c =  param[3]*fudge;
  433.    }
  434.  
  435.    /* precalculations for speed */
  436.    l_adt = multiply(l_a,l_dt,bitshift);
  437.    l_bdt = multiply(l_b,l_dt,bitshift);
  438.    l_cdt = multiply(l_c,l_dt,bitshift);
  439.    return(1);
  440. }
  441.  
  442. int orbit3dfloatsetup()
  443. {
  444.    connect = 1;
  445.    waste = 100;
  446.    projection = 2;
  447.  
  448.    if(fractype==FPHENON || fractype==FPPICKOVER || fractype==FPGINGERBREAD
  449.         || fractype == KAMFP || fractype == KAM3DFP
  450.         || fractype == FPHOPALONG || fractype == INVERSEJULIAFP)
  451.       connect=0;
  452.    if(fractype==FPLORENZ3D1 || fractype==FPLORENZ3D3 ||
  453.       fractype==FPLORENZ3D4)
  454.       waste = 750;
  455.    if(fractype==FPROSSLER)
  456.       waste = 500;
  457.    if(fractype==FPLORENZ)
  458.       projection = 1; /* plot x and z */
  459.  
  460.    initorbit[0] = 1;  /* initial conditions */
  461.    initorbit[1] = 1;
  462.    initorbit[2] = 1;
  463.    if(fractype==FPGINGERBREAD)
  464.    {
  465.       initorbit[0] = param[0];    /* initial conditions */
  466.       initorbit[1] = param[1];
  467.    }
  468.  
  469.    if(fractype==ICON || fractype==ICON3D)        /* DMF */
  470.    {
  471.       initorbit[0] = 0.01;  /* initial conditions */
  472.       initorbit[1] = 0.003;
  473.       connect = 0;
  474.       waste = 2000;
  475.    }
  476.  
  477.    if(fractype==FPHENON || fractype==FPPICKOVER)
  478.    {
  479.       a =  param[0];
  480.       b =  param[1];
  481.       c =  param[2];
  482.       d =  param[3];
  483.    }
  484.    else if(fractype==ICON || fractype==ICON3D)        /* DMF */
  485.    {
  486.       initorbit[0] = 0.01;  /* initial conditions */
  487.       initorbit[1] = 0.003;
  488.       connect = 0;
  489.       waste = 2000;
  490.       /* Initialize parameters */
  491.       a  =   param[0];
  492.       b  =   param[1];
  493.       c  =   param[2];
  494.       d  =   param[3];
  495.    }
  496.    else if(fractype==KAMFP || fractype==KAM3DFP)
  497.    {
  498.       a = param[0];          /* angle */
  499.       if(param[1] <= 0.0)
  500.      param[1] = .01;
  501.       b =  param[1];    /* stepsize */
  502.       c =  param[2];    /* stop */
  503.       t = l_d =  param[3];     /* points per orbit */
  504.       sinx = sin(a);
  505.       cosx = cos(a);
  506.       orbit = 0;
  507.       initorbit[0] = initorbit[1] = initorbit[2] = 0;
  508.    }
  509.    else if(fractype==FPHOPALONG || fractype==FPMARTIN)
  510.    {
  511.       initorbit[0] = 0;  /* initial conditions */
  512.       initorbit[1] = 0;
  513.       initorbit[2] = 0;
  514.       connect = 0;
  515.       a =  param[0];
  516.       b =  param[1];
  517.       c =  param[2];
  518.       d =  param[3];
  519.    }
  520.    else if (fractype == INVERSEJULIAFP)
  521.    {
  522.       _CMPLX Sqrt;
  523.  
  524.       Cx = param[0];
  525.       Cy = param[1];
  526.  
  527.       maxhits    = (int) param[2];
  528.       run_length = (int) param[3];
  529.       if (maxhits == 0)
  530.       maxhits = 1;
  531.       else if (maxhits >= colors)
  532.       maxhits = colors - 1;
  533.  
  534.       setup_convert_to_screen(&cvt);
  535.  
  536.       /* find fixed points: guaranteed to be in the set */
  537.       Sqrt = ComplexSqrtFloat(1 - 4 * Cx, -4 * Cy);
  538.       switch ((int) major_method) {
  539.      case breadth_first:
  540.         if (Init_Queue((long)32*1024) == 0)
  541.         { /* can't get queue memory: fall back to random walk */
  542.            stopmsg(20, NoQueue);
  543.            major_method = random_walk;
  544.            goto rwalk;
  545.         }
  546.         EnQueueFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
  547.         EnQueueFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
  548.         break;
  549.      case depth_first:            /* depth first (choose direction) */
  550.         if (Init_Queue((long)32*1024) == 0)
  551.         { /* can't get queue memory: fall back to random walk */
  552.            stopmsg(20, NoQueue);
  553.            major_method = random_walk;
  554.            goto rwalk;
  555.         }
  556.         switch (minor_method) {
  557.            case left_first:
  558.           PushFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
  559.           PushFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
  560.           break;
  561.            case right_first:
  562.           PushFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
  563.           PushFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
  564.           break;
  565.         }
  566.         break;
  567.      case random_walk:
  568. rwalk:
  569.         new.x = initorbit[0] = 1 + Sqrt.x / 2;
  570.         new.y = initorbit[1] = Sqrt.y / 2;
  571.         break;
  572.      case random_run:    /* random run, choose intervals */
  573.         major_method = random_run;
  574.         new.x = initorbit[0] = 1 + Sqrt.x / 2;
  575.         new.y = initorbit[1] = Sqrt.y / 2;
  576.         break;
  577.       }
  578.    }
  579.    else
  580.    {
  581.       dt = param[0];
  582.       a =  param[1];
  583.       b =  param[2];
  584.       c =  param[3];
  585.  
  586.    }
  587.  
  588.    /* precalculations for speed */
  589.    adt = a*dt;
  590.    bdt = b*dt;
  591.    cdt = c*dt;
  592.  
  593.    return(1);
  594. }
  595.  
  596. /******************************************************************/
  597. /*   orbit functions - put in fractalspecific[fractype].orbitcalc */
  598. /******************************************************************/
  599.  
  600. /* Julia sets by inverse iterations added by Juan J. Buhler 4/3/92 */
  601. /* Integrated with Lorenz by Tim Wegner 7/20/92 */
  602. /* Add Modified Inverse Iteration Method, 11/92 by Michael Snyder  */
  603.  
  604. int
  605. Minverse_julia_orbit()
  606. {
  607.    static int   random_dir = 0, random_len = 0;
  608.    int    newrow, newcol;
  609.    int    color,  leftright;
  610.  
  611.    /*
  612.     * First, compute new point
  613.     */
  614.    switch (major_method) {
  615.       case breadth_first:
  616.      if (QueueEmpty())
  617.         return -1;
  618.      new = DeQueueFloat();
  619.      break;
  620.       case depth_first:
  621.      if (QueueEmpty())
  622.         return -1;
  623.      new = PopFloat();
  624.      break;
  625.       case random_walk:
  626. #if 0
  627.      new = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
  628.      if (RANDOM(2))
  629.      {
  630.         new.x = -new.x;
  631.         new.y = -new.y;
  632.      }
  633. #endif
  634.      break;
  635.       case random_run:
  636. #if 0
  637.      new = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
  638.      if (random_len == 0)
  639.      {
  640.         random_len = RANDOM(run_length);
  641.         random_dir = RANDOM(3);
  642.      }
  643.      switch (random_dir) {
  644.         case 0:    /* left */
  645.            break;
  646.         case 1:    /* right */
  647.            new.x = -new.x;
  648.            new.y = -new.y;
  649.            break;
  650.         case 2:    /* random direction */
  651.            if (RANDOM(2))
  652.            {
  653.           new.x = -new.x;
  654.           new.y = -new.y;
  655.            }
  656.            break;
  657.      }
  658. #endif
  659.      break;
  660.    }
  661.  
  662.    /*
  663.     * Next, find its pixel position
  664.     */
  665.    newcol = cvt.a * new.x + cvt.b * new.y + cvt.e;
  666.    newrow = cvt.c * new.x + cvt.d * new.y + cvt.f;
  667.  
  668.    /*
  669.     * Now find the next point(s), and flip a coin to choose one.
  670.     */
  671.  
  672.    new       = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
  673.    leftright = (RANDOM(2)) ? 1 : -1;
  674.  
  675.    if (newcol < 1 || newcol >= xdots || newrow < 1 || newrow >= ydots)
  676.    {
  677.       /*
  678.        * MIIM must skip points that are off the screen boundary,
  679.        * since it cannot read their color.
  680.        */
  681.       switch (major_method) {
  682.      case breadth_first:
  683.         EnQueueFloat(leftright * new.x, leftright * new.y);
  684.         return 1;
  685.      case depth_first:
  686.         PushFloat   (leftright * new.x, leftright * new.y);
  687.         return 1;
  688.      case random_run:
  689.      case random_walk:
  690.         break;
  691.       }
  692.    }
  693.  
  694.    /*
  695.     * Read the pixel's color:
  696.     * For MIIM, if color >= maxhits, discard the point
  697.     *           else put the point's children onto the queue
  698.     */
  699.    color  = getcolor(newcol, newrow);
  700.    switch (major_method) {
  701.       case breadth_first:
  702.      if (color < maxhits)
  703.      {
  704.         putcolor(newcol, newrow, color+1);
  705. /*        new = ComplexSqrtFloat(new.x - Cx, new.y - Cy); */
  706.         EnQueueFloat( new.x,  new.y);
  707.         EnQueueFloat(-new.x, -new.y);
  708.      }
  709.      break;
  710.       case depth_first:
  711.      if (color < maxhits)
  712.      {
  713.         putcolor(newcol, newrow, color+1);
  714. /*        new = ComplexSqrtFloat(new.x - Cx, new.y - Cy); */
  715.         if (minor_method == left_first)
  716.         {
  717.            if (QueueFullAlmost())
  718.           PushFloat(-new.x, -new.y);
  719.            else
  720.            {
  721.           PushFloat( new.x,  new.y);
  722.           PushFloat(-new.x, -new.y);
  723.            }
  724.         }
  725.         else
  726.         {
  727.            if (QueueFullAlmost())
  728.           PushFloat( new.x,  new.y);
  729.            else
  730.            {
  731.           PushFloat(-new.x, -new.y);
  732.           PushFloat( new.x,  new.y);
  733.            }
  734.         }
  735.      }
  736.      break;
  737.       case random_run:
  738.      if (random_len-- == 0)
  739.      {
  740.         random_len = RANDOM(run_length);
  741.         random_dir = RANDOM(3);
  742.      }
  743.      switch (random_dir) {
  744.         case 0:    /* left */
  745.            break;
  746.         case 1:    /* right */
  747.            new.x = -new.x;
  748.            new.y = -new.y;
  749.            break;
  750.         case 2:    /* random direction */
  751.            new.x = leftright * new.x;
  752.            new.y = leftright * new.y;
  753.            break;
  754.      }
  755.      if (color < colors-1)
  756.         putcolor(newcol, newrow, color+1);
  757.      break;
  758.       case random_walk:
  759.      if (color < colors-1)
  760.         putcolor(newcol, newrow, color+1);
  761.      new.x = leftright * new.x;
  762.      new.y = leftright * new.y;
  763.      break;
  764.    }
  765.    return 1;
  766.  
  767. }
  768.  
  769. int
  770. Linverse_julia_orbit()
  771. {
  772.    static int   random_dir = 0, random_len = 0;
  773.    int    newrow, newcol;
  774.    int    color;
  775.  
  776.    /*
  777.     * First, compute new point
  778.     */
  779.    switch (major_method) {
  780.       case breadth_first:
  781.      if (QueueEmpty())
  782.         return -1;
  783.      lnew = DeQueueLong();
  784.      break;
  785.       case depth_first:
  786.      if (QueueEmpty())
  787.         return -1;
  788.      lnew = PopLong();
  789.      break;
  790.       case random_walk:
  791.      lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  792.      if (RANDOM(2))
  793.      {
  794.         lnew.x = -lnew.x;
  795.         lnew.y = -lnew.y;
  796.      }
  797.      break;
  798.       case random_run:
  799.      lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  800.      if (random_len == 0)
  801.      {
  802.         random_len = RANDOM(run_length);
  803.         random_dir = RANDOM(3);
  804.      }
  805.      switch (random_dir) {
  806.         case 0:    /* left */
  807.            break;
  808.         case 1:    /* right */
  809.            lnew.x = -lnew.x;
  810.            lnew.y = -lnew.y;
  811.            break;
  812.         case 2:    /* random direction */
  813.            if (RANDOM(2))
  814.            {
  815.           lnew.x = -lnew.x;
  816.           lnew.y = -lnew.y;
  817.            }
  818.            break;
  819.      }
  820.    }
  821.  
  822.    /*
  823.     * Next, find its pixel position
  824.     *
  825.     * Note: had to use a bitshift of 21 for this operation because
  826.     * otherwise the values of lcvt were truncated.  Used bitshift
  827.     * of 24 otherwise, for increased precision.
  828.     */
  829.    newcol = (multiply(lcvt.a, lnew.x >> (bitshift - 21), 21) +
  830.          multiply(lcvt.b, lnew.y >> (bitshift - 21), 21) + lcvt.e) >> 21;
  831.    newrow = (multiply(lcvt.c, lnew.x >> (bitshift - 21), 21) +
  832.          multiply(lcvt.d, lnew.y >> (bitshift - 21), 21) + lcvt.f) >> 21;
  833.  
  834.    if (newcol < 1 || newcol >= xdots || newrow < 1 || newrow >= ydots)
  835.    {
  836.       /*
  837.        * MIIM must skip points that are off the screen boundary,
  838.        * since it cannot read their color.
  839.        */
  840.       if (RANDOM(2))
  841.      color =  1;
  842.       else
  843.      color = -1;
  844.       switch (major_method) {
  845.      case breadth_first:
  846.         lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  847.         EnQueueLong(color * lnew.x, color * lnew.y);
  848.         break;
  849.      case depth_first:
  850.         lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  851.         PushLong(color * lnew.x, color * lnew.y);
  852.         break;
  853.      case random_run:
  854.         random_len--;
  855.      case random_walk:
  856.         break;
  857.       }
  858.       return 1;
  859.    }
  860.  
  861.    /*
  862.     * Read the pixel's color:
  863.     * For MIIM, if color >= maxhits, discard the point
  864.     *           else put the point's children onto the queue
  865.     */
  866.    color  = getcolor(newcol, newrow);
  867.    switch (major_method) {
  868.       case breadth_first:
  869.      if (color < maxhits)
  870.      {
  871.         putcolor(newcol, newrow, color+1);
  872.         lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  873.         EnQueueLong( lnew.x,  lnew.y);
  874.         EnQueueLong(-lnew.x, -lnew.y);
  875.      }
  876.      break;
  877.       case depth_first:
  878.      if (color < maxhits)
  879.      {
  880.         putcolor(newcol, newrow, color+1);
  881.         lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
  882.         if (minor_method == left_first)
  883.         {
  884.            if (QueueFullAlmost())
  885.           PushLong(-lnew.x, -lnew.y);
  886.            else
  887.            {
  888.           PushLong( lnew.x,  lnew.y);
  889.           PushLong(-lnew.x, -lnew.y);
  890.            }
  891.         }
  892.         else
  893.         {
  894.            if (QueueFullAlmost())
  895.           PushLong( lnew.x,  lnew.y);
  896.            else
  897.            {
  898.           PushLong(-lnew.x, -lnew.y);
  899.           PushLong( lnew.x,  lnew.y);
  900.            }
  901.         }
  902.      }
  903.      break;
  904.       case random_run:
  905.      random_len--;
  906.      /* fall through */
  907.       case random_walk:
  908.      if (color < colors-1)
  909.         putcolor(newcol, newrow, color+1);
  910.      break;
  911.    }
  912.    return 1;
  913. }
  914.  
  915. #if 0
  916. int inverse_julia_orbit(double *x, double *y, double *z)
  917. {
  918.    double r, xo, yo;
  919.    int waste;
  920.    if(*z >= 1.0) /* this assumes intial value is 1.0!!! */
  921.    {
  922.       waste = 20; /* skip these points at first */
  923.       *z = 0;
  924.    }
  925.    else
  926.       waste = 1;
  927.    while(waste--)
  928.    {
  929.       xo = *x - param[0]; 
  930.       yo = *y - param[1];
  931.       r  = sqrt(xo*xo + yo*yo);
  932.       *x  = sqrt((r + xo)/2);
  933.       if (yo < 0)
  934.          *x = - *x;
  935.       *y = sqrt((r - xo)/2);
  936.       if(RANDOM(10) > 4)
  937.       {
  938.           *x = -(*x);
  939.           *y = -(*y);
  940.       }
  941.    }
  942.    return(0);
  943. }
  944. #endif
  945.  
  946. int lorenz3dlongorbit(long *l_x, long *l_y, long *l_z)
  947. {
  948.       l_xdt = multiply(*l_x,l_dt,bitshift);
  949.       l_ydt = multiply(*l_y,l_dt,bitshift);
  950.       l_dx  = -multiply(l_adt,*l_x,bitshift) + multiply(l_adt,*l_y,bitshift);
  951.       l_dy  =  multiply(l_bdt,*l_x,bitshift) -l_ydt -multiply(*l_z,l_xdt,bitshift);
  952.       l_dz  = -multiply(l_cdt,*l_z,bitshift) + multiply(*l_x,l_ydt,bitshift);
  953.  
  954.       *l_x += l_dx;
  955.       *l_y += l_dy;
  956.       *l_z += l_dz;
  957.       return(0);
  958. }
  959.  
  960. int lorenz3d1floatorbit(double *x, double *y, double *z)
  961. {
  962.       double norm;
  963.  
  964.       xdt = (*x)*dt;
  965.       ydt = (*y)*dt;
  966.       zdt = (*z)*dt;
  967.  
  968.       /* 1-lobe Lorenz */
  969.       norm = sqrt((*x)*(*x)+(*y)*(*y));
  970.       dx   = (-adt-dt)*(*x) + (adt-bdt)*(*y) + (dt-adt)*norm + ydt*(*z);
  971.       dy   = (bdt-adt)*(*x) - (adt+dt)*(*y) + (bdt+adt)*norm - xdt*(*z) -
  972.          norm*zdt;
  973.       dz   = (ydt/2) - cdt*(*z);
  974.  
  975.       *x += dx;
  976.       *y += dy;
  977.       *z += dz;
  978.       return(0);
  979. }
  980.  
  981. int lorenz3dfloatorbit(double *x, double *y, double *z)
  982. {
  983.       xdt = (*x)*dt;
  984.       ydt = (*y)*dt;
  985.       zdt = (*z)*dt;
  986.  
  987.       /* 2-lobe Lorenz (the original) */
  988.       dx  = -adt*(*x) + adt*(*y);
  989.       dy  =  bdt*(*x) - ydt - (*z)*xdt;
  990.       dz  = -cdt*(*z) + (*x)*ydt;
  991.  
  992.       *x += dx;
  993.       *y += dy;
  994.       *z += dz;
  995.       return(0);
  996. }
  997.  
  998. int lorenz3d3floatorbit(double *x, double *y, double *z)
  999. {
  1000.       double norm;
  1001.  
  1002.       xdt = (*x)*dt;
  1003.       ydt = (*y)*dt;
  1004.       zdt = (*z)*dt;
  1005.  
  1006.       /* 3-lobe Lorenz */
  1007.       norm = sqrt((*x)*(*x)+(*y)*(*y));
  1008.       dx   = (-(adt+dt)*(*x) + (adt-bdt+zdt)*(*y)) / 3 +
  1009.          ((dt-adt)*((*x)*(*x)-(*y)*(*y)) +
  1010.          2*(bdt+adt-zdt)*(*x)*(*y))/(3*norm);
  1011.       dy   = ((bdt-adt-zdt)*(*x) - (adt+dt)*(*y)) / 3 +
  1012.          (2*(adt-dt)*(*x)*(*y) +
  1013.          (bdt+adt-zdt)*((*x)*(*x)-(*y)*(*y)))/(3*norm);
  1014.       dz   = (3*xdt*(*x)*(*y)-ydt*(*y)*(*y))/2 - cdt*(*z);
  1015.  
  1016.       *x += dx;
  1017.       *y += dy;
  1018.       *z += dz;
  1019.       return(0);
  1020. }
  1021.  
  1022. int lorenz3d4floatorbit(double *x, double *y, double *z)
  1023. {
  1024.       xdt = (*x)*dt;
  1025.       ydt = (*y)*dt;
  1026.       zdt = (*z)*dt;
  1027.  
  1028.       /* 4-lobe Lorenz */
  1029.       dx   = (-adt*(*x)*(*x)*(*x) + (2*adt+bdt-zdt)*(*x)*(*x)*(*y) +
  1030.          (adt-2*dt)*(*x)*(*y)*(*y) + (zdt-bdt)*(*y)*(*y)*(*y)) /
  1031.          (2 * ((*x)*(*x)+(*y)*(*y)));
  1032.       dy   = ((bdt-zdt)*(*x)*(*x)*(*x) + (adt-2*dt)*(*x)*(*x)*(*y) +
  1033.          (-2*adt-bdt+zdt)*(*x)*(*y)*(*y) - adt*(*y)*(*y)*(*y)) /
  1034.          (2 * ((*x)*(*x)+(*y)*(*y)));
  1035.       dz   = (2*xdt*(*x)*(*x)*(*y) - 2*xdt*(*y)*(*y)*(*y) - cdt*(*z));
  1036.  
  1037.       *x += dx;
  1038.       *y += dy;
  1039.       *z += dz;
  1040.       return(0);
  1041. }
  1042.  
  1043. int henonfloatorbit(double *x, double *y, double *z)
  1044. {
  1045.       double newx,newy;
  1046.       newx  = 1 + *y - a*(*x)*(*x);
  1047.       newy  = b*(*x);
  1048.       *x = newx;
  1049.       *y = newy;
  1050.       return(0);
  1051. }
  1052.  
  1053. int henonlongorbit(long *l_x, long *l_y, long *l_z)
  1054. {
  1055.       long newx,newy;
  1056.       newx = multiply(*l_x,*l_x,bitshift);
  1057.       newx = multiply(newx,l_a,bitshift);
  1058.       newx  = fudge + *l_y - newx;
  1059.       newy  = multiply(l_b,*l_x,bitshift);
  1060.       *l_x = newx;
  1061.       *l_y = newy;
  1062.       return(0);
  1063. }
  1064.  
  1065. int rosslerfloatorbit(double *x, double *y, double *z)
  1066. {
  1067.       xdt = (*x)*dt;
  1068.       ydt = (*y)*dt;
  1069.  
  1070.       dx = -ydt - (*z)*dt;
  1071.       dy = xdt + (*y)*adt;
  1072.       dz = bdt + (*z)*xdt - (*z)*cdt;
  1073.  
  1074.       *x += dx;
  1075.       *y += dy;
  1076.       *z += dz;
  1077.       return(0);
  1078. }
  1079.  
  1080. int pickoverfloatorbit(double *x, double *y, double *z)
  1081. {
  1082.       double newx,newy,newz;
  1083.       newx = sin(a*(*y)) - (*z)*cos(b*(*x));
  1084.       newy = (*z)*sin(c*(*x)) - cos(d*(*y));
  1085.       newz = sin(*x);
  1086.       *x = newx;
  1087.       *y = newy;
  1088.       *z = newz;
  1089.       return(0);
  1090. }
  1091. /* page 149 "Science of Fractal Images" */
  1092. int gingerbreadfloatorbit(double *x, double *y, double *z)
  1093. {
  1094.       double newx;
  1095.       newx = 1 - (*y) + fabs(*x);
  1096.       *y = *x;
  1097.       *x = newx;
  1098.       return(0);
  1099. }
  1100.  
  1101. int rosslerlongorbit(long *l_x, long *l_y, long *l_z)
  1102. {
  1103.       l_xdt = multiply(*l_x,l_dt,bitshift);
  1104.       l_ydt = multiply(*l_y,l_dt,bitshift);
  1105.  
  1106.       l_dx  = -l_ydt - multiply(*l_z,l_dt,bitshift);
  1107.       l_dy  =  l_xdt + multiply(*l_y,l_adt,bitshift);
  1108.       l_dz  =  l_bdt + multiply(*l_z,l_xdt,bitshift)
  1109.              - multiply(*l_z,l_cdt,bitshift);
  1110.  
  1111.       *l_x += l_dx;
  1112.       *l_y += l_dy;
  1113.       *l_z += l_dz;
  1114.  
  1115.       return(0);
  1116. }
  1117.  
  1118. /* OSTEP  = Orbit Step (and inner orbit value) */
  1119. /* NTURNS = Outside Orbit */
  1120. /* TURN2  = Points per orbit */
  1121. /* a      = Angle */
  1122.  
  1123.  
  1124. int kamtorusfloatorbit(double *r, double *s, double *z)
  1125. {
  1126.    double srr;
  1127.    if(t++ >= l_d)
  1128.    {
  1129.       orbit += b;
  1130.       (*r) = (*s) = orbit/3;
  1131.       t = 0;
  1132.       *z = orbit;
  1133.       if(orbit > c)
  1134.      return(1);
  1135.    }
  1136.    srr = (*s)-(*r)*(*r);
  1137.    (*s)=(*r)*sinx+srr*cosx;
  1138.    (*r)=(*r)*cosx-srr*sinx;
  1139.    return(0);
  1140. }
  1141.  
  1142. int kamtoruslongorbit(long *r, long *s, long *z)
  1143. {
  1144.    long srr;
  1145.    if(t++ >= l_d)
  1146.    {
  1147.       l_orbit += l_b;
  1148.       (*r) = (*s) = l_orbit/3;
  1149.       t = 0;
  1150.       *z = l_orbit;
  1151.       if(l_orbit > l_c)
  1152.      return(1);
  1153.    }
  1154.    srr = (*s)-multiply((*r),(*r),bitshift);
  1155.    (*s)=multiply((*r),l_sinx,bitshift)+multiply(srr,l_cosx,bitshift);
  1156.    (*r)=multiply((*r),l_cosx,bitshift)-multiply(srr,l_sinx,bitshift);
  1157.    return(0);
  1158. }
  1159. /*#define sign(x) ((x)>0?1:((x)<0?(-1):0))*/
  1160. #define sign(x) ((x)>=0?1:-1)
  1161. int hopalong2dfloatorbit(double *x, double *y, double *z)
  1162. {
  1163.    double tmp;
  1164.    tmp = *y - sign(*x)*sqrt(fabs(b*(*x)-c));
  1165.    *y = a - *x;
  1166.    *x = tmp;
  1167.    return(0);
  1168. }
  1169.  
  1170. int martin2dfloatorbit(double *x, double *y, double *z)
  1171. {
  1172.    double tmp;
  1173.    tmp = *y - sin(*x);
  1174.    *y = a - *x;
  1175.    *x = tmp;
  1176.    return(0);
  1177. }
  1178.  
  1179. int mandelcloudfloat(double *x, double *y, double *z)
  1180. {
  1181.     double newx,newy,x2,y2;
  1182.     x2 = (*x)*(*x);
  1183.     y2 = (*y)*(*y);
  1184.     if (x2+y2>2) return 1;
  1185.     newx = x2-y2+a;
  1186.     newy = 2*(*x)*(*y)+b;
  1187.     *x = newx;
  1188.     *y = newy;
  1189.     return(0);
  1190. }
  1191.  
  1192. int dynamfloat(double *x, double *y, double *z)
  1193. {
  1194.       _CMPLX cp,tmp;
  1195.       double newx,newy;
  1196.       cp.x = b* *x;
  1197.       cp.y = 0;
  1198.       CMPLXtrig0(cp, tmp);
  1199.       newy = *y + dt*sin(*x + a*tmp.x);
  1200.       if (euler) {
  1201.       *y = newy;
  1202.       }
  1203.  
  1204.       cp.x = b* *y;
  1205.       cp.y = 0;
  1206.       CMPLXtrig0(cp, tmp);
  1207.       newx = *x - dt*sin(*y + a*tmp.x);
  1208.       *x = newx;
  1209.       *y = newy;
  1210.       return(0);
  1211. }
  1212.  
  1213. /* dmf */
  1214. #undef  LAMBDA
  1215. #define LAMBDA  param[0]
  1216. #define ALPHA   param[1]
  1217. #define BETA    param[2]
  1218. #define GAMMA   param[3]
  1219. #define OMEGA   param[4]
  1220. #define DEGREE  param[5]
  1221.  
  1222. int iconfloatorbit(double *x, double *y, double *z)
  1223. {
  1224.  
  1225.     double oldx, oldy, zzbar, zreal, zimag, za, zb, zn, p;
  1226.     unsigned char i;
  1227.  
  1228.     oldx = *x;
  1229.     oldy = *y;
  1230.  
  1231.     zzbar = oldx * oldx + oldy * oldy;
  1232.     zreal = oldx;
  1233.     zimag = oldy;
  1234.  
  1235.     for(i=1; i <= DEGREE-2; i++) {
  1236.         za = zreal * oldx - zimag * oldy;
  1237.         zb = zimag * oldx + zreal * oldy;
  1238.         zreal = za;
  1239.         zimag = zb;
  1240.     }
  1241.     zn = oldx * zreal - oldy * zimag;
  1242.     p = LAMBDA + ALPHA * zzbar + BETA * zn;
  1243.     *x = p * oldx + GAMMA * zreal - OMEGA * oldy;
  1244.     *y = p * oldy - GAMMA * zimag + OMEGA * oldx;
  1245.  
  1246. /*    if (fractype==ICON3D) */
  1247.     *z = zzbar; 
  1248.     return(0);
  1249. }
  1250. #ifdef LAMBDA  /* Tim says this will make me a "good citizen" */
  1251. #undef LAMBDA  /* Yeah, but you were bad, Dan - LAMBDA was already */
  1252. #undef ALPHA   /* defined! <grin!> TW */
  1253. #undef BETA
  1254. #undef GAMMA
  1255. #endif
  1256. /**********************************************************************/
  1257. /*   Main fractal engines - put in fractalspecific[fractype].calctype */
  1258. /**********************************************************************/
  1259.  
  1260. int inverse_julia_per_image()
  1261. {
  1262.    int color = 0;
  1263.  
  1264.    if (resuming)            /* can't resume */
  1265.       return -1;
  1266.  
  1267.    while (color >= 0)       /* generate points */
  1268.    {
  1269.       if (check_key())
  1270.       {
  1271.      Free_Queue();
  1272.      return -1;
  1273.       }
  1274.       color = curfractalspecific->orbitcalc();
  1275.       old = new;
  1276.    }
  1277.    Free_Queue();
  1278.    return 0;
  1279. }
  1280.  
  1281. int orbit2dfloat()
  1282. {
  1283.    FILE *fp;
  1284.    double *soundvar;
  1285.    double x,y,z;
  1286.    int color,col,row;
  1287.    int count;
  1288.    int oldrow, oldcol;
  1289.    double *p0,*p1,*p2;
  1290.    struct affine cvt;
  1291.    int ret,start;
  1292.    start = 1;
  1293.    
  1294.    fp = open_orbitsave();
  1295.    /* setup affine screen coord conversion */
  1296.    setup_convert_to_screen(&cvt);
  1297.  
  1298.    /* set up projection scheme */
  1299.    if(projection==0)
  1300.    {
  1301.       p0 = &z;
  1302.       p1 = &x;
  1303.       p2 = &y;
  1304.    }
  1305.    else if(projection==1)
  1306.    {
  1307.       p0 = &x;
  1308.       p1 = &z;
  1309.       p2 = &y;
  1310.    }
  1311.    else if(projection==2)
  1312.    {
  1313.       p0 = &x;
  1314.       p1 = &y;
  1315.       p2 = &z;
  1316.    }
  1317.    if(soundflag==1)
  1318.       soundvar = &x;
  1319.    else if(soundflag==2)
  1320.       soundvar = &y;
  1321.    else if(soundflag==3)
  1322.       soundvar = &z;
  1323.  
  1324.    count = 0;
  1325.    if(inside > 0)
  1326.       color = inside;
  1327.    if(color >= colors)
  1328.       color = 1;
  1329.    oldcol = oldrow = -1;
  1330.    x = initorbit[0];
  1331.    y = initorbit[1];
  1332.    z = initorbit[2];
  1333.  
  1334.    if (resuming)
  1335.    {
  1336.       start_resume();
  1337.       get_resume(sizeof(count),&count,sizeof(color),&color,
  1338.           sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
  1339.           sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
  1340.           sizeof(t),&t,sizeof(orbit),&orbit,
  1341.           0);
  1342.       end_resume();
  1343.    }
  1344.  
  1345.    ret = 0;
  1346.    while(1)
  1347.    {
  1348.       if(check_key())
  1349.       {
  1350.          nosnd();
  1351.          alloc_resume(100,1);
  1352.          put_resume(sizeof(count),&count,sizeof(color),&color,
  1353.              sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
  1354.              sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
  1355.              sizeof(t),&t,sizeof(orbit),&orbit,
  1356.              0);
  1357.          ret = -1;
  1358.          break;
  1359.       }
  1360.  
  1361.       if (++count > 1000)
  1362.       {        /* time to switch colors? */
  1363.          count = 0;
  1364.          if (++color >= colors)   /* another color to switch to? */
  1365.         color = 1;  /* (don't use the background color) */
  1366.       }
  1367.  
  1368.       col = cvt.a*x + cvt.b*y + cvt.e;
  1369.       row = cvt.c*x + cvt.d*y + cvt.f;
  1370.       if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
  1371.       {
  1372.          if (soundflag > 0)
  1373.             snd((int)(*soundvar*100+basehertz));
  1374. /* dmf */
  1375.          if(fractype!=ICON)
  1376.          {
  1377.          if(oldcol != -1 && connect)
  1378.             draw_line(col,row,oldcol,oldrow,color&(colors-1));
  1379.             else
  1380.             (*plot)(col,row,color&(colors-1));
  1381.          } else {
  1382.             /* should this be using plothist()? */
  1383.             color = getcolor(col,row)+1;
  1384.             if( color < colors ) /* color sticks on last value */
  1385.                (*plot)(col,row,color);
  1386.  
  1387.          }
  1388.  
  1389.          oldcol = col;
  1390.          oldrow = row;
  1391.          start = 0;
  1392.       }
  1393.       else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
  1394.          return(ret);
  1395.       else   
  1396.          oldrow = oldcol = -1;
  1397.  
  1398.       if(curfractalspecific->orbitcalc(p0, p1, p2))
  1399.          break;
  1400.       if(fp)
  1401.          fprintf(fp,orbitsave_format,*p0,*p1,0.0);
  1402.    }
  1403.    if(fp)
  1404.       fclose(fp);
  1405.    return(ret);
  1406. }
  1407.  
  1408. int orbit2dlong()
  1409. {
  1410.    FILE *fp;
  1411.    long *soundvar;
  1412.    long x,y,z;
  1413.    int color,col,row;
  1414.    int count;
  1415.    int oldrow, oldcol;
  1416.    long *p0,*p1,*p2;
  1417.    struct l_affine cvt;
  1418.    int ret,start;
  1419.    start = 1;
  1420.    fp = open_orbitsave();
  1421.  
  1422.    /* setup affine screen coord conversion */
  1423.    l_setup_convert_to_screen(&cvt);
  1424.  
  1425.    /* set up projection scheme */
  1426.    if(projection==0)
  1427.    {
  1428.       p0 = &z;
  1429.       p1 = &x;
  1430.       p2 = &y;
  1431.    }
  1432.    else if(projection==1)
  1433.    {
  1434.       p0 = &x;
  1435.       p1 = &z;
  1436.       p2 = &y;
  1437.    }
  1438.    else if(projection==2)
  1439.    {
  1440.       p0 = &x;
  1441.       p1 = &y;
  1442.       p2 = &z;
  1443.    }
  1444.    if(soundflag==1)
  1445.       soundvar = &x;
  1446.    else if(soundflag==2)
  1447.       soundvar = &y;
  1448.    else if(soundflag==3)
  1449.       soundvar = &z;
  1450.    count = 0;
  1451.    if(inside > 0)
  1452.       color = inside;
  1453.    if(color >= colors)
  1454.       color = 1;
  1455.    oldcol = oldrow = -1;
  1456.    x = initorbitlong[0];
  1457.    y = initorbitlong[1];
  1458.    z = initorbitlong[2];
  1459.  
  1460.    if (resuming)
  1461.    {
  1462.       start_resume();
  1463.       get_resume(sizeof(count),&count,sizeof(color),&color,
  1464.           sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
  1465.           sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
  1466.           sizeof(t),&t,sizeof(l_orbit),&l_orbit,
  1467.           0);
  1468.       end_resume();
  1469.    }
  1470.  
  1471.    ret = 0;
  1472.    while(1)
  1473.    {
  1474.       if(check_key())
  1475.       {
  1476.          nosnd();
  1477.          alloc_resume(100,1);
  1478.          put_resume(sizeof(count),&count,sizeof(color),&color,
  1479.          sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
  1480.              sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
  1481.              sizeof(t),&t,sizeof(l_orbit),&l_orbit,
  1482.              0);
  1483.          ret = -1;
  1484.          break;
  1485.       }
  1486.       if (++count > 1000)
  1487.       {        /* time to switch colors? */
  1488.          count = 0;
  1489.          if (++color >= colors)   /* another color to switch to? */
  1490.             color = 1;  /* (don't use the background color) */
  1491.       }
  1492.  
  1493.       col = (multiply(cvt.a,x,bitshift) + multiply(cvt.b,y,bitshift) + cvt.e) >> bitshift;
  1494.       row = (multiply(cvt.c,x,bitshift) + multiply(cvt.d,y,bitshift) + cvt.f) >> bitshift;
  1495.       if(overflow)
  1496.       {
  1497.          overflow = 0;
  1498.          return(ret);
  1499.       }
  1500.       if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
  1501.       {
  1502.          if (soundflag > 0)
  1503.          {
  1504.             double yy;
  1505.             yy = *soundvar;
  1506.             yy = yy/fudge;
  1507.             snd((int)(yy*100+basehertz));
  1508.          }
  1509.          if(oldcol != -1 && connect)
  1510.             draw_line(col,row,oldcol,oldrow,color&(colors-1));
  1511.          else if(!start)
  1512.             (*plot)(col,row,color&(colors-1));
  1513.          oldcol = col;
  1514.          oldrow = row;
  1515.          start = 0;
  1516.       }
  1517.       else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
  1518.          return(ret);
  1519.       else   
  1520.      oldrow = oldcol = -1;
  1521.  
  1522.       /* Calculate the next point */
  1523.       if(curfractalspecific->orbitcalc(p0, p1, p2))
  1524.          break;
  1525.       if(fp)
  1526.          fprintf(fp,orbitsave_format,(double)*p0/fudge,(double)*p1/fudge,0.0);
  1527.    }
  1528.    if(fp)
  1529.       fclose(fp);
  1530.    return(ret);
  1531. }
  1532.  
  1533. int orbit3dlongcalc()
  1534. {
  1535.    FILE *fp;
  1536.    unsigned count;
  1537.    int oldcol,oldrow;
  1538.    int oldcol1,oldrow1;
  1539.    struct long3dvtinf inf;
  1540.    unsigned long maxct;
  1541.    int color;
  1542.    int ret;
  1543.  
  1544.    /* setup affine screen coord conversion */
  1545.    l_setup_convert_to_screen(&inf.cvt);
  1546.  
  1547.    oldcol1 = oldrow1 = oldcol = oldrow = -1;
  1548.    color = 2;
  1549.    if(color >= colors)
  1550.       color = 1;
  1551.  
  1552.    inf.orbit[0] = initorbitlong[0];
  1553.    inf.orbit[1] = initorbitlong[1];
  1554.    inf.orbit[2] = initorbitlong[2];
  1555.  
  1556.    if(diskvideo)                /* this would KILL a disk drive! */
  1557.       notdiskmsg();
  1558.  
  1559.    fp = open_orbitsave();
  1560.  
  1561.    /* make maxct a function of screen size               */
  1562.    maxct = maxit*40L;
  1563.    count = inf.ct = 0L;
  1564.    ret = 0;
  1565.    while(inf.ct++ < maxct) /* loop until keypress or maxit */
  1566.    {
  1567.       /* calc goes here */
  1568.       if (++count > 1000)
  1569.       {        /* time to switch colors? */
  1570.          count = 0;
  1571.          if (++color >= colors)   /* another color to switch to? */
  1572.             color = 1;        /* (don't use the background color) */
  1573.       }
  1574.       if(check_key())
  1575.       {
  1576.          nosnd();
  1577.          ret = -1;
  1578.          break;
  1579.       }
  1580.  
  1581.       curfractalspecific->orbitcalc(&inf.orbit[0],&inf.orbit[1],&inf.orbit[2]);
  1582.       if(fp)
  1583.          fprintf(fp,orbitsave_format,(double)inf.orbit[0]/fudge,(double)inf.orbit[1]/fudge,(double)inf.orbit[2]/fudge);
  1584.       if (long3dviewtransf(&inf))
  1585.       {
  1586.          /* plot if inside window */
  1587.          if (inf.col >= 0)
  1588.          {
  1589.             if(realtime)
  1590.                whichimage=1;
  1591.             if (soundflag > 0)
  1592.             {
  1593.                double yy;
  1594.                yy = inf.viewvect[soundflag-1];
  1595.                yy = yy/fudge;
  1596.                snd((int)(yy*100+basehertz));
  1597.             }
  1598.             if(oldcol != -1 && connect)
  1599.                draw_line(inf.col,inf.row,oldcol,oldrow,color&(colors-1));
  1600.             else
  1601.                (*plot)(inf.col,inf.row,color&(colors-1));
  1602.          }
  1603.          else if (inf.col == -2)
  1604.             return(ret);
  1605.          oldcol = inf.col;
  1606.          oldrow = inf.row;
  1607.          if(realtime)
  1608.          {
  1609.             whichimage=2;
  1610.             /* plot if inside window */
  1611.             if (inf.col1 >= 0)
  1612.             {
  1613.                if(oldcol1 != -1 && connect)
  1614.                   draw_line(inf.col1,inf.row1,oldcol1,oldrow1,color&(colors-1));
  1615.                else
  1616.                   (*plot)(inf.col1,inf.row1,color&(colors-1));
  1617.             }
  1618.             else if (inf.col1 == -2)
  1619.                return(ret);
  1620.             oldcol1 = inf.col1;
  1621.             oldrow1 = inf.row1;
  1622.          }
  1623.       }
  1624.    }
  1625.    if(fp)
  1626.       fclose(fp);
  1627.    return(ret);
  1628. }
  1629.  
  1630.  
  1631. int orbit3dfloatcalc()
  1632. {
  1633.    FILE *fp;
  1634.    unsigned count;
  1635.    int oldcol,oldrow;
  1636.    int oldcol1,oldrow1;
  1637.    extern int init3d[];
  1638.    unsigned long maxct;
  1639.    int color;
  1640.    int ret;
  1641.    struct float3dvtinf inf;
  1642.  
  1643.    /* setup affine screen coord conversion */
  1644.    setup_convert_to_screen(&inf.cvt);
  1645.  
  1646.    oldcol = oldrow = -1;
  1647.    oldcol1 = oldrow1 = -1;
  1648.    color = 2;
  1649.    if(color >= colors)
  1650.       color = 1;
  1651.    inf.orbit[0] = initorbit[0];
  1652.    inf.orbit[1] = initorbit[1];
  1653.    inf.orbit[2] = initorbit[2];
  1654.  
  1655.    if(diskvideo)                /* this would KILL a disk drive! */
  1656.       notdiskmsg();
  1657.  
  1658.    fp = open_orbitsave();
  1659.  
  1660.    maxct = maxit*40L;
  1661.    count = inf.ct = 0L;
  1662.    ret = 0;
  1663.    while(inf.ct++ < maxct) /* loop until keypress or maxit */
  1664.    {
  1665.       /* calc goes here */
  1666.       if (++count > 1000)
  1667.       {        /* time to switch colors? */
  1668.          count = 0;
  1669.          if (++color >= colors)   /* another color to switch to? */
  1670.             color = 1;        /* (don't use the background color) */
  1671.       }
  1672.  
  1673.       if(check_key())
  1674.       {
  1675.          nosnd();
  1676.          ret = -1;
  1677.          break;
  1678.       }
  1679.  
  1680.       curfractalspecific->orbitcalc(&inf.orbit[0],&inf.orbit[1],&inf.orbit[2]);
  1681.       if(fp)
  1682.          fprintf(fp,orbitsave_format,inf.orbit[0],inf.orbit[1],inf.orbit[2]);
  1683.       if (float3dviewtransf(&inf))
  1684.       {
  1685.          /* plot if inside window */
  1686.          if (inf.col >= 0)
  1687.          {
  1688.         if(realtime)
  1689.                whichimage=1;
  1690.             if (soundflag > 0)
  1691.                snd((int)(inf.viewvect[soundflag-1]*100+basehertz));
  1692.             if(oldcol != -1 && connect)
  1693.                draw_line(inf.col,inf.row,oldcol,oldrow,color&(colors-1));
  1694.             else
  1695.                (*plot)(inf.col,inf.row,color&(colors-1));
  1696.          }
  1697.          else if (inf.col == -2)
  1698.             return(ret);
  1699.          oldcol = inf.col;
  1700.          oldrow = inf.row;
  1701.          if(realtime)
  1702.          {
  1703.             whichimage=2;
  1704.             /* plot if inside window */
  1705.             if (inf.col1 >= 0)
  1706.             {
  1707.                if(oldcol1 != -1 && connect)
  1708.                   draw_line(inf.col1,inf.row1,oldcol1,oldrow1,color&(colors-1));
  1709.                else
  1710.                   (*plot)(inf.col1,inf.row1,color&(colors-1));
  1711.             }
  1712.             else if (inf.col1 == -2)
  1713.                return(ret);
  1714.             oldcol1 = inf.col1;
  1715.             oldrow1 = inf.row1;
  1716.          }
  1717.       }
  1718.    }
  1719.    if(fp)
  1720.       fclose(fp);
  1721.    return(ret);
  1722. }
  1723.  
  1724. int dynam2dfloatsetup()
  1725. {
  1726.    connect = 0;
  1727.    euler = 0;
  1728.    d = param[0]; /* number of intervals */
  1729.    if (d<0) {
  1730.       d = -d;
  1731.       connect = 1;
  1732.    } 
  1733.    else if (d==0) {
  1734.       d = 1;
  1735.    }
  1736.    if (fractype==DYNAMICFP) {
  1737.        a = param[2]; /* parameter */
  1738.        b = param[3]; /* parameter */
  1739.        dt = param[1]; /* step size */
  1740.        if (dt<0) {
  1741.       dt = -dt;
  1742.       euler = 1;
  1743.        }
  1744.        if (dt==0) dt = 0.01;
  1745.    }
  1746.    if (outside == -5) {
  1747.        plot = plothist;
  1748.    }
  1749.    return(1);
  1750. }
  1751.  
  1752. /*
  1753.  * This is the routine called to perform a time-discrete dynamical
  1754.  * system image.
  1755.  * The starting positions are taken by stepping across the image in steps
  1756.  * of parameter1 pixels.  maxit differential equation steps are taken, with
  1757.  * a step size of parameter2.
  1758.  */
  1759. int dynam2dfloat()
  1760. {
  1761.    FILE *fp;
  1762.    double *soundvar;
  1763.    double x,y,z;
  1764.    int color,col,row;
  1765.    int count;
  1766.    int oldrow, oldcol;
  1767.    double *p0,*p1;
  1768.    struct affine cvt;
  1769.    int ret;
  1770.    int xstep, ystep; /* The starting position step number */
  1771.    double xpixel, ypixel; /* Our pixel position on the screen */
  1772.  
  1773.    fp = open_orbitsave();
  1774.    /* setup affine screen coord conversion */
  1775.    setup_convert_to_screen(&cvt);
  1776.  
  1777.    p0 = &x;
  1778.    p1 = &y;
  1779.  
  1780.  
  1781.    if(soundflag==1)
  1782.       soundvar = &x;
  1783.    else if(soundflag==2)
  1784.       soundvar = &y;
  1785.    else if(soundflag==3)
  1786.       soundvar = &z;
  1787.  
  1788.    count = 0;
  1789.    if(inside > 0)
  1790.       color = inside;
  1791.    if(color >= colors)
  1792.       color = 1;
  1793.    oldcol = oldrow = -1;
  1794.  
  1795.    xstep = -1;
  1796.    ystep = 0;
  1797.  
  1798.    if (resuming) {
  1799.        start_resume();
  1800.        get_resume(sizeof(count),&count, sizeof(color),&color,
  1801.          sizeof(oldrow),&oldrow, sizeof(oldcol),&oldcol,
  1802.          sizeof(x),&x, sizeof(y), &y, sizeof(xstep), &xstep,
  1803.          sizeof(ystep), &ystep, 0);
  1804.        end_resume();
  1805.    }
  1806.  
  1807.    ret = 0;
  1808.    while(1)
  1809.    {
  1810.       if(check_key())
  1811.       {
  1812.          nosnd();
  1813.          alloc_resume(100,1);
  1814.          put_resume(sizeof(count),&count, sizeof(color),&color,
  1815.              sizeof(oldrow),&oldrow, sizeof(oldcol),&oldcol,
  1816.              sizeof(x),&x, sizeof(y), &y, sizeof(xstep), &xstep,
  1817.              sizeof(ystep), &ystep, 0);
  1818.          ret = -1;
  1819.          break;
  1820.       }
  1821.  
  1822.       xstep ++;
  1823.       if (xstep>=d) {
  1824.       xstep = 0;
  1825.       ystep ++;
  1826.       if (ystep>d) {
  1827.           nosnd();
  1828.           ret = -1;
  1829.           break;
  1830.       }
  1831.       }
  1832.  
  1833.       xpixel = dxsize*(xstep+.5)/d;
  1834.       ypixel = dysize*(ystep+.5)/d;
  1835.       x = (xxmin+delxx*xpixel) + (delxx2*ypixel);
  1836.       y = (yymax-delyy*ypixel) + (-delyy2*xpixel);
  1837.       if (fractype==MANDELCLOUD) {
  1838.       a = x;
  1839.       b = y;
  1840.       }
  1841.       oldcol = -1;
  1842.  
  1843.       if (++color >= colors)   /* another color to switch to? */
  1844.       color = 1;    /* (don't use the background color) */
  1845.  
  1846.       for (count=0;count<maxit;count++) {
  1847.  
  1848.       col = cvt.a*x + cvt.b*y + cvt.e;
  1849.       row = cvt.c*x + cvt.d*y + cvt.f;
  1850.       if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
  1851.       {
  1852.          if (soundflag > 0)
  1853.            snd((int)(*soundvar*100+basehertz));
  1854.  
  1855.          if (count>=orbit_delay) {
  1856.          if(oldcol != -1 && connect)
  1857.             draw_line(col,row,oldcol,oldrow,color&(colors-1));
  1858.          else if(count > 0 || fractype != MANDELCLOUD)
  1859.             (*plot)(col,row,color&(colors-1));
  1860.          }
  1861.          oldcol = col;
  1862.          oldrow = row;
  1863.       }
  1864.       else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
  1865.             return(ret);
  1866.       else
  1867.          oldrow = oldcol = -1;
  1868.  
  1869.       if(curfractalspecific->orbitcalc(p0, p1, NULL))
  1870.          break;
  1871.       if(fp)
  1872.           fprintf(fp,orbitsave_format,*p0,*p1,0.0);
  1873.     }
  1874.    }
  1875.    if(fp)
  1876.       fclose(fp);
  1877.    return(ret);
  1878. }
  1879.  
  1880. /* this function's only purpose is to manage funnyglasses related */
  1881. /* stuff so the code is not duplicated for ifs3d() and lorenz3d() */
  1882. int funny_glasses_call(int (*calc)())
  1883. {
  1884.    int status;
  1885.    status = 0;
  1886.    if(glassestype)
  1887.       whichimage = 1;
  1888.    else
  1889.       whichimage = 0;
  1890.    plot_setup();
  1891.    plot = standardplot;
  1892.    status = calc();
  1893.    if(realtime && glassestype != 3)
  1894.    {
  1895.       realtime = 0;
  1896.       return(status);
  1897.    }
  1898.    if(glassestype && status == 0 && display3d)
  1899.    {
  1900.       if(glassestype==3) /* photographer's mode */
  1901.      if(active_system == 0) { /* dos version */
  1902.         int i;
  1903. static char far firstready[]={"\
  1904. First image (left eye) is ready.  Hit any key to see it,\n\
  1905. then hit <s> to save, hit any other key to create second image."};
  1906.         stopmsg(16,firstready);
  1907.         while ((i = getakey()) == 's' || i == 'S') {
  1908.            diskisactive = 1;
  1909.            savetodisk(savename);
  1910.            diskisactive = 0;
  1911.            }
  1912.         /* is there a better way to clear the screen in graphics mode? */
  1913.         setvideomode(videoentry.videomodeax,
  1914.         videoentry.videomodebx,
  1915.         videoentry.videomodecx,
  1916.         videoentry.videomodedx);
  1917.      }
  1918.      else {           /* Windows version */
  1919. static char far firstready2[]={"First (Left Eye) image is complete"};
  1920.         stopmsg(0,firstready2);
  1921.         clear_screen();
  1922.         }
  1923.       whichimage = 2;
  1924.       plot_setup();
  1925.       plot = standardplot;
  1926.       /* is there a better way to clear the graphics screen ? */
  1927.       if(status = calc())
  1928.      return(status);
  1929.       if(glassestype==3) /* photographer's mode */
  1930.      if(active_system == 0) { /* dos version */
  1931. static char far secondready[]={"Second image (right eye) is ready"};
  1932.         stopmsg(16,secondready);
  1933.      }
  1934.    }
  1935.    return(status);
  1936. }
  1937.  
  1938. /* double version - mainly for testing */
  1939. static int ifs3dfloat()
  1940. {
  1941.    int color_method;
  1942.    FILE *fp;
  1943.    unsigned long maxct;
  1944.    int color;
  1945.  
  1946.    double newx,newy,newz,r,sum;
  1947.  
  1948.    int k;
  1949.    int ret;
  1950.  
  1951.    struct float3dvtinf inf;
  1952.  
  1953.    float far *ffptr;
  1954.  
  1955.    /* setup affine screen coord conversion */
  1956.    setup_convert_to_screen(&inf.cvt);
  1957.    srand(1);
  1958.    color_method = param[0];
  1959.    if(diskvideo)                /* this would KILL a disk drive! */
  1960.       notdiskmsg();
  1961.  
  1962.    inf.orbit[0] = 0;
  1963.    inf.orbit[1] = 0;
  1964.    inf.orbit[2] = 0;
  1965.  
  1966.    fp = open_orbitsave();
  1967.  
  1968.    maxct = maxit*40L;
  1969.    inf.ct = 0L;
  1970.    ret = 0;
  1971.    while(inf.ct++ < maxct) /* loop until keypress or maxit */
  1972.    {
  1973.       if( check_key() )  /* keypress bails out */
  1974.       {
  1975.      ret = -1;
  1976.      break;
  1977.       }
  1978.       r = rand15();     /* generate fudged random number between 0 and 1 */
  1979.       r /= 32767;
  1980.  
  1981.       /* pick which iterated function to execute, weighted by probability */
  1982.       sum = ifs_defn[12]; /* [0][12] */
  1983.       k = 0;
  1984.       while ( sum < r)
  1985.       {
  1986.      k++;
  1987.      sum += ifs_defn[k*IFS3DPARM+12];
  1988.      if (ifs_defn[(k+1)*IFS3DPARM+12] == 0) break; /* for safety */
  1989.       }
  1990.  
  1991.       /* calculate image of last point under selected iterated function */
  1992.       ffptr = ifs_defn + k*IFS3DPARM; /* point to first parm in row */
  1993.       newx = *ffptr * inf.orbit[0] +
  1994.          *(ffptr+1) * inf.orbit[1] +
  1995.          *(ffptr+2) * inf.orbit[2] + *(ffptr+9);
  1996.       newy = *(ffptr+3) * inf.orbit[0] +
  1997.          *(ffptr+4) * inf.orbit[1] +
  1998.          *(ffptr+5) * inf.orbit[2] + *(ffptr+10);
  1999.       newz = *(ffptr+6) * inf.orbit[0] +
  2000.          *(ffptr+7) * inf.orbit[1] +
  2001.          *(ffptr+8) * inf.orbit[2] + *(ffptr+11);
  2002.  
  2003.       inf.orbit[0] = newx;
  2004.       inf.orbit[1] = newy;
  2005.       inf.orbit[2] = newz;
  2006.       if(fp)
  2007.       fprintf(fp,orbitsave_format,newx,newy,newz);
  2008.       if (float3dviewtransf(&inf))
  2009.       {
  2010.      /* plot if inside window */
  2011.      if (inf.col >= 0)
  2012.      {
  2013.         if(realtime)
  2014.            whichimage=1;
  2015.             if(color_method)
  2016.                color = (k&(colors-1))+1;
  2017.             else
  2018.         color = getcolor(inf.col,inf.row)+1;
  2019.         if( color < colors ) /* color sticks on last value */
  2020.            (*plot)(inf.col,inf.row,color);
  2021.      }
  2022.          else if (inf.col == -2)
  2023.             return(ret);
  2024.      if(realtime)
  2025.      {
  2026.         whichimage=2;
  2027.         /* plot if inside window */
  2028.         if (inf.col1 >= 0)
  2029.         {
  2030.               if(color_method)
  2031.                  color = (k&(colors-1))+1;
  2032.               else
  2033.             color = getcolor(inf.col1,inf.row1)+1;
  2034.             if( color < colors ) /* color sticks on last value */
  2035.           (*plot)(inf.col1,inf.row1,color);
  2036.         }
  2037.         else if (inf.col1 == -2)
  2038.                return(ret);
  2039.      }
  2040.       }
  2041.    } /* end while */
  2042.    if(fp)
  2043.       fclose(fp);
  2044.    return(ret);
  2045. }
  2046.  
  2047. int ifs()            /* front-end for ifs2d and ifs3d */
  2048. {
  2049.    if (ifs_defn == NULL && ifsload() < 0)
  2050.       return(-1);
  2051.    if(diskvideo)                /* this would KILL a disk drive! */
  2052.       notdiskmsg();
  2053.    return((ifs_type == 0) ? ifs2d() : ifs3d());
  2054. }
  2055.  
  2056.  
  2057. /* IFS logic shamelessly converted to integer math */
  2058. int ifs2d()
  2059. {
  2060.    int color_method;
  2061.    FILE *fp;
  2062.    unsigned long maxct,ct;
  2063.    int col;
  2064.    int row;
  2065.    int color;
  2066.    int ret;
  2067.    long far *localifs;
  2068.    long far *lfptr;
  2069.    long x,y,newx,newy,r,sum, tempr;
  2070.  
  2071.    int i,j,k;
  2072.    struct l_affine cvt;
  2073.    /* setup affine screen coord conversion */
  2074.    l_setup_convert_to_screen(&cvt);
  2075.  
  2076.    srand(1);
  2077.    color_method = param[0];
  2078.    if((localifs=(long far *)farmemalloc((long)numaffine*IFSPARM*sizeof(long)))==NULL)
  2079.    {
  2080.       stopmsg(0,insufficient_ifs_mem);
  2081.       return(-1);
  2082.    }
  2083.  
  2084.    for (i = 0; i < numaffine; i++)    /* fill in the local IFS array */
  2085.       for (j = 0; j < IFSPARM; j++)
  2086.      localifs[i*IFSPARM+j] = ifs_defn[i*IFSPARM+j] * fudge;
  2087.  
  2088.    tempr = fudge / 32767;     /* find the proper rand() fudge */
  2089.  
  2090.    fp = open_orbitsave();
  2091.  
  2092.    /* make maxct a function of screen size         */
  2093.    /* 1k times maxit at EGA resolution seems about right */
  2094.    maxct = (float)maxit*(1024.0*xdots*ydots)/(640.0*350.0);
  2095.    ct = 0L;
  2096.    x = y = 0;
  2097.    ret = 0;
  2098.    while(ct++ < maxct) /* loop until keypress or maxit */
  2099.    {
  2100.       if( check_key() )  /* keypress bails out */
  2101.       {
  2102.      ret = -1;
  2103.      break;
  2104.       }
  2105.       r = rand15();     /* generate fudged random number between 0 and 1 */
  2106.       r *= tempr;
  2107.  
  2108.       /* pick which iterated function to execute, weighted by probability */
  2109.       sum = localifs[6];  /* [0][6] */
  2110.       k = 0;
  2111.       while ( sum < r && k < numaffine-1) /* fixed bug of error if sum < 1 */
  2112.      sum += localifs[++k*IFSPARM+6];
  2113.       /* calculate image of last point under selected iterated function */
  2114.       lfptr = localifs + k*IFSPARM; /* point to first parm in row */
  2115.       newx = multiply(lfptr[0],x,bitshift) + 
  2116.              multiply(lfptr[1],y,bitshift) + lfptr[4];
  2117.       newy = multiply(lfptr[2],x,bitshift) + 
  2118.              multiply(lfptr[3],y,bitshift) + lfptr[5];
  2119.       x = newx;
  2120.       y = newy;
  2121.       if(fp)
  2122.      fprintf(fp,orbitsave_format,(double)newx/fudge,(double)newy/fudge,0.0);
  2123.  
  2124.       /* plot if inside window */
  2125.       col = (multiply(cvt.a,x,bitshift) + multiply(cvt.b,y,bitshift) + cvt.e) >> bitshift;
  2126.       row = (multiply(cvt.c,x,bitshift) + multiply(cvt.d,y,bitshift) + cvt.f) >> bitshift;
  2127.       if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
  2128.       {
  2129.      /* color is count of hits on this pixel */
  2130.          if(color_method)
  2131.             color = (k&(colors-1))+1;
  2132.          else
  2133.      color = getcolor(col,row)+1;
  2134.      if( color < colors ) /* color sticks on last value */
  2135.         (*plot)(col,row,color);
  2136.       }
  2137.       else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
  2138.             return(ret);
  2139.    }
  2140.    if(fp)
  2141.       fclose(fp);
  2142.    farmemfree(localifs);
  2143.    return(ret);
  2144. }
  2145.  
  2146. static int ifs3dlong()
  2147. {
  2148.    int color_method;   
  2149.    FILE *fp;
  2150.    extern int init3d[];
  2151.    unsigned long maxct;
  2152.    int color;
  2153.    int ret;
  2154.  
  2155.    long far *localifs;
  2156.    long far *lfptr;
  2157.    long newx,newy,newz,r,sum, tempr;
  2158.  
  2159.    int i,j,k;
  2160.  
  2161.    struct long3dvtinf inf;
  2162.    srand(1);
  2163.    color_method = param[0];
  2164.    if((localifs=(long far *)farmemalloc((long)numaffine*IFS3DPARM*sizeof(long)))==NULL)
  2165.    {
  2166.       stopmsg(0,insufficient_ifs_mem);
  2167.       return(-1);
  2168.    }
  2169.  
  2170.    /* setup affine screen coord conversion */
  2171.    l_setup_convert_to_screen(&inf.cvt);
  2172.  
  2173.    for (i = 0; i < numaffine; i++)    /* fill in the local IFS array */
  2174.       for (j = 0; j < IFS3DPARM; j++)
  2175.      localifs[i*IFS3DPARM+j] = ifs_defn[i*IFS3DPARM+j] * fudge;
  2176.  
  2177.    tempr = fudge / 32767;     /* find the proper rand() fudge */
  2178.  
  2179.    inf.orbit[0] = 0;
  2180.    inf.orbit[1] = 0;
  2181.    inf.orbit[2] = 0;
  2182.  
  2183.    fp = open_orbitsave();
  2184.  
  2185.    maxct = maxit*40L;
  2186.    inf.ct = 0L;
  2187.    ret = 0;
  2188.    while(inf.ct++ < maxct) /* loop until keypress or maxit */
  2189.    {
  2190.       if( check_key() )  /* keypress bails out */
  2191.       {
  2192.      ret = -1;
  2193.      break;
  2194.       }
  2195.       r = rand15();     /* generate fudged random number between 0 and 1 */
  2196.       r *= tempr;
  2197.  
  2198.       /* pick which iterated function to execute, weighted by probability */
  2199.       sum = localifs[12];  /* [0][12] */
  2200.       k = 0;
  2201.       while ( sum < r && ++k < numaffine*IFS3DPARM)
  2202.      sum += localifs[k*IFS3DPARM+12];
  2203.  
  2204.       /* calculate image of last point under selected iterated function */
  2205.       lfptr = localifs + k*IFS3DPARM; /* point to first parm in row */
  2206.  
  2207.       /* calculate image of last point under selected iterated function */
  2208.       newx = multiply(lfptr[0], inf.orbit[0], bitshift) +
  2209.              multiply(lfptr[1], inf.orbit[1], bitshift) +
  2210.          multiply(lfptr[2], inf.orbit[2], bitshift) + lfptr[9];
  2211.       newy = multiply(lfptr[3], inf.orbit[0], bitshift) +
  2212.          multiply(lfptr[4], inf.orbit[1], bitshift) +
  2213.          multiply(lfptr[5], inf.orbit[2], bitshift) + lfptr[10];
  2214.       newz = multiply(lfptr[6], inf.orbit[0], bitshift) +
  2215.          multiply(lfptr[7], inf.orbit[1], bitshift) +
  2216.          multiply(lfptr[8], inf.orbit[2], bitshift) + lfptr[11];
  2217.  
  2218.       inf.orbit[0] = newx;
  2219.       inf.orbit[1] = newy;
  2220.       inf.orbit[2] = newz;
  2221.       if(fp)
  2222.      fprintf(fp,orbitsave_format,(double)newx/fudge,(double)newy/fudge,(double)newz/fudge);
  2223.  
  2224.       if (long3dviewtransf(&inf))
  2225.       {
  2226.      if((long)abs(inf.row) + (long)abs(inf.col) > BAD_PIXEL) /* sanity check */
  2227.             return(ret);
  2228.      /* plot if inside window */
  2229.      if (inf.col >= 0)
  2230.      {
  2231.         if(realtime)
  2232.            whichimage=1;
  2233.             if(color_method)
  2234.                color = (k&(colors-1))+1;
  2235.             else
  2236.         color = getcolor(inf.col,inf.row)+1;
  2237.         if( color < colors ) /* color sticks on last value */
  2238.            (*plot)(inf.col,inf.row,color);
  2239.      }
  2240.      if(realtime)
  2241.      {
  2242.         whichimage=2;
  2243.         /* plot if inside window */
  2244.         if (inf.col1 >= 0)
  2245.         {
  2246.                if(color_method)
  2247.                   color = (k&(colors-1))+1;
  2248.                else
  2249.            color = getcolor(inf.col1,inf.row1)+1;
  2250.            if( color < colors ) /* color sticks on last value */
  2251.           (*plot)(inf.col1,inf.row1,color);
  2252.         }
  2253.      }
  2254.       }
  2255.    }
  2256.    if(fp)
  2257.       fclose(fp);
  2258.    farmemfree(localifs);
  2259.    return(ret);
  2260. }
  2261.  
  2262. static void setupmatrix(MATRIX doublemat)
  2263. {
  2264.    /* build transformation matrix */
  2265.    identity (doublemat);
  2266.  
  2267.    /* apply rotations - uses the same rotation variables as line3d.c */
  2268.    xrot ((double)XROT / 57.29577,doublemat);
  2269.    yrot ((double)YROT / 57.29577,doublemat);
  2270.    zrot ((double)ZROT / 57.29577,doublemat);
  2271.  
  2272.    /* apply scale */
  2273. /*   scale((double)XSCALE/100.0,(double)YSCALE/100.0,(double)ROUGH/100.0,doublemat);*/
  2274.  
  2275. }
  2276.  
  2277. int orbit3dfloat()
  2278. {
  2279.    display3d = -1;
  2280.    if(0 < glassestype && glassestype < 3)
  2281.       realtime = 1;
  2282.    else
  2283.       realtime = 0;
  2284.    return(funny_glasses_call(orbit3dfloatcalc));
  2285. }
  2286.  
  2287. int orbit3dlong()
  2288. {
  2289.    display3d = -1;
  2290.    if(0 < glassestype && glassestype < 3)
  2291.       realtime = 1;
  2292.    else
  2293.       realtime = 0;
  2294.    return(funny_glasses_call(orbit3dlongcalc));
  2295. }
  2296.  
  2297. int ifs3d()
  2298. {
  2299.    display3d = -1;
  2300.  
  2301.    if(0 < glassestype && glassestype < 3)
  2302.       realtime = 1;
  2303.    else
  2304.       realtime = 0;
  2305.    if(floatflag)
  2306.       return(funny_glasses_call(ifs3dfloat)); /* double version of ifs3d */
  2307.    else
  2308.       return(funny_glasses_call(ifs3dlong));  /* long version of ifs3d     */
  2309. }
  2310.  
  2311.  
  2312.  
  2313. static int long3dviewtransf(struct long3dvtinf *inf)
  2314. {
  2315.    int i,j;
  2316.    double tmpx, tmpy, tmpz;
  2317.    long tmp;
  2318.  
  2319.    if (inf->ct == 1)    /* initialize on first call */
  2320.    {
  2321.       for(i=0;i<3;i++)
  2322.       {
  2323.      inf->minvals[i] =  1L << 30;
  2324.      inf->maxvals[i] = -inf->minvals[i];
  2325.       }
  2326.       setupmatrix(inf->doublemat);
  2327.       if(realtime)
  2328.      setupmatrix(inf->doublemat1);
  2329.       /* copy xform matrix to long for for fixed point math */
  2330.       for (i = 0; i < 4; i++)
  2331.      for (j = 0; j < 4; j++)
  2332.      {
  2333.         inf->longmat[i][j] = inf->doublemat[i][j] * fudge;
  2334.         if(realtime)
  2335.            inf->longmat1[i][j] = inf->doublemat1[i][j] * fudge;
  2336.      }
  2337.    }
  2338.  
  2339.    /* 3D VIEWING TRANSFORM */
  2340.    longvmult(inf->orbit,inf->longmat,inf->viewvect,bitshift);
  2341.    if(realtime)
  2342.       longvmult(inf->orbit,inf->longmat1,inf->viewvect1,bitshift);
  2343.  
  2344.    if(inf->ct <= waste) /* waste this many points to find minz and maxz */
  2345.    {
  2346.       /* find minz and maxz */
  2347.       for(i=0;i<3;i++)
  2348.      if ((tmp = inf->viewvect[i]) < inf->minvals[i])
  2349.         inf->minvals[i] = tmp;
  2350.      else if (tmp > inf->maxvals[i])
  2351.         inf->maxvals[i] = tmp;
  2352.  
  2353.       if(inf->ct == waste) /* time to work it out */
  2354.       {
  2355.      inf->iview[0] = inf->iview[1] = 0L; /* center viewer on origin */
  2356.  
  2357.      /* z value of user's eye - should be more negative than extreme
  2358.             negative part of image */
  2359.      inf->iview[2] = (long)((inf->minvals[2]-inf->maxvals[2])*(double)ZVIEWER/100.0);
  2360.  
  2361.      /* center image on origin */
  2362.      tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0*fudge); /* center x */
  2363.      tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0*fudge); /* center y */
  2364.  
  2365.      /* apply perspective shift */
  2366.      tmpx += ((double)xshift*(xxmax-xxmin))/(xdots);
  2367.      tmpy += ((double)yshift*(yymax-yymin))/(ydots);
  2368.      tmpz = -((double)inf->maxvals[2]) / fudge;
  2369.      trans(tmpx,tmpy,tmpz,inf->doublemat);
  2370.  
  2371.      if(realtime)
  2372.      {
  2373.         /* center image on origin */
  2374.         tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0*fudge); /* center x */
  2375.         tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0*fudge); /* center y */
  2376.  
  2377.         tmpx += ((double)xshift1*(xxmax-xxmin))/(xdots);
  2378.         tmpy += ((double)yshift1*(yymax-yymin))/(ydots);
  2379.         tmpz = -((double)inf->maxvals[2]) / fudge;
  2380.         trans(tmpx,tmpy,tmpz,inf->doublemat1);
  2381.      }
  2382.      for(i=0;i<3;i++)
  2383.         view[i] = (double)inf->iview[i] / fudge;
  2384.  
  2385.      /* copy xform matrix to long for for fixed point math */
  2386.      for (i = 0; i < 4; i++)
  2387.         for (j = 0; j < 4; j++)
  2388.         {
  2389.            inf->longmat[i][j] = inf->doublemat[i][j] * fudge;
  2390.            if(realtime)
  2391.           inf->longmat1[i][j] = inf->doublemat1[i][j] * fudge;
  2392.         }
  2393.       }
  2394.       return(0);
  2395.    }
  2396.  
  2397.    /* inf->ct > waste */
  2398.    /* apply perspective if requested */
  2399.    if(ZVIEWER)
  2400.    {
  2401.       if(debugflag==22 || ZVIEWER < 100) /* use float for small persp */
  2402.       {
  2403.      /* use float perspective calc */
  2404.      VECTOR tmpv;
  2405.      for(i=0;i<3;i++)
  2406.         tmpv[i] = (double)inf->viewvect[i] / fudge;
  2407.      perspective(tmpv);
  2408.      for(i=0;i<3;i++)
  2409.         inf->viewvect[i] = tmpv[i]*fudge;
  2410.      if(realtime)
  2411.      {
  2412.         for(i=0;i<3;i++)
  2413.            tmpv[i] = (double)inf->viewvect1[i] / fudge;
  2414.         perspective(tmpv);
  2415.         for(i=0;i<3;i++)
  2416.            inf->viewvect1[i] = tmpv[i]*fudge;
  2417.      }
  2418.       }
  2419.       else
  2420.       {
  2421.      longpersp(inf->viewvect,inf->iview,bitshift);
  2422.      if(realtime)
  2423.         longpersp(inf->viewvect1,inf->iview,bitshift);
  2424.       }
  2425.    }
  2426.  
  2427.    /* work out the screen positions */
  2428.    inf->row = ((multiply(inf->cvt.c,inf->viewvect[0],bitshift) +
  2429.         multiply(inf->cvt.d,inf->viewvect[1],bitshift) + inf->cvt.f)
  2430.         >> bitshift)
  2431.           + yyadjust;
  2432.    inf->col = ((multiply(inf->cvt.a,inf->viewvect[0],bitshift) +
  2433.         multiply(inf->cvt.b,inf->viewvect[1],bitshift) + inf->cvt.e)
  2434.         >> bitshift)
  2435.           + xxadjust;
  2436.    if (inf->col < 0 || inf->col >= xdots || inf->row < 0 || inf->row >= ydots)
  2437.    {
  2438.       if((long)abs(inf->col)+(long)abs(inf->row) > BAD_PIXEL)
  2439.         inf->col= inf->row = -2;
  2440.       else
  2441.         inf->col= inf->row = -1;
  2442.    }    
  2443.    if(realtime)
  2444.    {
  2445.       inf->row1 = ((multiply(inf->cvt.c,inf->viewvect1[0],bitshift) +
  2446.             multiply(inf->cvt.d,inf->viewvect1[1],bitshift) +
  2447.             inf->cvt.f) >> bitshift)
  2448.           + yyadjust1;
  2449.       inf->col1 = ((multiply(inf->cvt.a,inf->viewvect1[0],bitshift) +
  2450.             multiply(inf->cvt.b,inf->viewvect1[1],bitshift) +
  2451.             inf->cvt.e) >> bitshift)
  2452.           + xxadjust1;
  2453.       if (inf->col1 < 0 || inf->col1 >= xdots || inf->row1 < 0 || inf->row1 >= ydots)
  2454.       {
  2455.          if((long)abs(inf->col1)+(long)abs(inf->row1) > BAD_PIXEL)
  2456.            inf->col1= inf->row1 = -2;
  2457.          else
  2458.            inf->col1= inf->row1 = -1;
  2459.       }    
  2460.    }
  2461.    return(1);
  2462. }
  2463.  
  2464. static int float3dviewtransf(struct float3dvtinf *inf)
  2465. {
  2466.    int i;
  2467.    double tmpx, tmpy, tmpz;
  2468.    double tmp;
  2469.  
  2470.    if (inf->ct == 1)    /* initialize on first call */
  2471.    {
  2472.       for(i=0;i<3;i++)
  2473.       {
  2474.      inf->minvals[i] =  100000.0; /* impossible value */
  2475.      inf->maxvals[i] = -100000.0;
  2476.       }
  2477.       setupmatrix(inf->doublemat);
  2478.       if(realtime)
  2479.      setupmatrix(inf->doublemat1);
  2480.    }
  2481.  
  2482.    /* 3D VIEWING TRANSFORM */
  2483.    vmult(inf->orbit,inf->doublemat,inf->viewvect );
  2484.    if(realtime)
  2485.       vmult(inf->orbit,inf->doublemat1,inf->viewvect1);
  2486.  
  2487.    if(inf->ct <= waste) /* waste this many points to find minz and maxz */
  2488.    {
  2489.       /* find minz and maxz */
  2490.       for(i=0;i<3;i++)
  2491.      if ((tmp = inf->viewvect[i]) < inf->minvals[i])
  2492.         inf->minvals[i] = tmp;
  2493.      else if (tmp > inf->maxvals[i])
  2494.         inf->maxvals[i] = tmp;
  2495.       if(inf->ct == waste) /* time to work it out */
  2496.       {
  2497.      view[0] = view[1] = 0; /* center on origin */
  2498.      /* z value of user's eye - should be more negative than extreme
  2499.                negative part of image */
  2500.      view[2] = (inf->minvals[2]-inf->maxvals[2])*(double)ZVIEWER/100.0;
  2501.  
  2502.      /* center image on origin */
  2503.      tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0); /* center x */
  2504.      tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0); /* center y */
  2505.  
  2506.      /* apply perspective shift */
  2507.      tmpx += ((double)xshift*(xxmax-xxmin))/(xdots);
  2508.      tmpy += ((double)yshift*(yymax-yymin))/(ydots);
  2509.      tmpz = -(inf->maxvals[2]);
  2510.      trans(tmpx,tmpy,tmpz,inf->doublemat);
  2511.  
  2512.      if(realtime)
  2513.      {
  2514.         /* center image on origin */
  2515.         tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0); /* center x */
  2516.         tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0); /* center y */
  2517.  
  2518.         tmpx += ((double)xshift1*(xxmax-xxmin))/(xdots);
  2519.         tmpy += ((double)yshift1*(yymax-yymin))/(ydots);
  2520.         tmpz = -(inf->maxvals[2]);
  2521.         trans(tmpx,tmpy,tmpz,inf->doublemat1);
  2522.         }
  2523.      }
  2524.       return(0);
  2525.       }
  2526.  
  2527.    /* inf->ct > waste */
  2528.    /* apply perspective if requested */
  2529.    if(ZVIEWER)
  2530.    {
  2531.       perspective(inf->viewvect);
  2532.       if(realtime)
  2533.      perspective(inf->viewvect1);
  2534.    }
  2535.    inf->row = inf->cvt.c*inf->viewvect[0] + inf->cvt.d*inf->viewvect[1]
  2536.         + inf->cvt.f + yyadjust;
  2537.    inf->col = inf->cvt.a*inf->viewvect[0] + inf->cvt.b*inf->viewvect[1]
  2538.         + inf->cvt.e + xxadjust;
  2539.    if (inf->col < 0 || inf->col >= xdots || inf->row < 0 || inf->row >= ydots)
  2540.    {
  2541.       if((long)abs(inf->col)+(long)abs(inf->row) > BAD_PIXEL)
  2542.         inf->col= inf->row = -2;
  2543.       else
  2544.         inf->col= inf->row = -1;
  2545.    }    
  2546.    if(realtime)
  2547.    {
  2548.       inf->row1 = inf->cvt.c*inf->viewvect1[0] + inf->cvt.d*inf->viewvect1[1]
  2549.         + inf->cvt.f + yyadjust1;
  2550.       inf->col1 = inf->cvt.a*inf->viewvect1[0] + inf->cvt.b*inf->viewvect1[1]
  2551.         + inf->cvt.e + xxadjust1;
  2552.       if (inf->col1 < 0 || inf->col1 >= xdots || inf->row1 < 0 || inf->row1 >= ydots)
  2553.       {
  2554.          if((long)abs(inf->col1)+(long)abs(inf->row1) > BAD_PIXEL)
  2555.            inf->col1= inf->row1 = -2;
  2556.          else
  2557.            inf->col1= inf->row1 = -1;
  2558.       }    
  2559.    }
  2560.    return(1);
  2561. }
  2562.  
  2563. static FILE *open_orbitsave()
  2564. {
  2565.    FILE *fp;
  2566.    if (orbitsave && (fp = fopen(orbitsavename,"w")))
  2567.    {
  2568.       fprintf(fp,"pointlist x y z color\n");
  2569.       return fp;
  2570.    }
  2571.    return NULL;
  2572. }
  2573.  
  2574. /* Plot a histogram by incrementing the pixel each time it it touched */
  2575. static void _fastcall plothist(x, y, color)
  2576. int x,y,color;
  2577. {
  2578.     color = getcolor(x,y)+1;
  2579.     if (color<colors) 
  2580.     putcolor(x,y,color);
  2581. }
  2582.  
  2583.  
  2584.  
  2585.  
  2586.